package org.example.leetcode;

/**
 * @Description: TODO
 * @Author wyatt
 * @Data 2024/05/28 14:41
 */

//3 x 3 的幻方是一个填充有 从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。
//
// 给定一个由整数组成的row x col 的 grid，其中有多少个 3 × 3 的 “幻方” 子矩阵？（每个子矩阵都是连续的）。
//
//
//
// 示例 1：
//
//
//
//
//输入: grid = [[4,3,8,4],[9,5,1,9],[2,7,6,2]]
//输出: 1
//解释:
//下面的子矩阵是一个 3 x 3 的幻方：
//
//而这一个不是：
//
//总的来说，在本示例所给定的矩阵中只有一个 3 x 3 的幻方子矩阵。
//
//
// 示例 2:
//
//
//输入: grid = [[8]]
//输出: 0
//
//
//
//
// 提示:
//
//
// row == grid.length
// col == grid[i].length
// 1 <= row, col <= 10
// 0 <= grid[i][j] <= 15
//
//
// Related Topics 数组 哈希表 数学 矩阵 👍 67 👎 0

public class Solution840 {

    public static void main(String[] args) {
        Solution840 solution840 = new Solution840();
        System.out.println(solution840.numMagicSquaresInside(new int[][]{{4,3,8,4},{9,5,1,9},{2,7,6,2}}));
    }

    public int numMagicSquaresInside(int[][] grid) {
        int count = 0;

        int row = grid.length;
        int col = grid[0].length;

        if(row < 3 || col < 3){
            return count;
        }

        for (int i = 0; i < grid.length-2; i++) {
            for (int j = 0; j < grid[i].length-2; j++) {
                if(grid[i+1][j+1] != 5) continue;
                //判断是 1-9
                if(!magicNum(grid, i , j)) continue;
                if((grid[i][j] + grid[i][j+1] + grid[i][j+2]) == 15
                        && (grid[i+1][j] + grid[i+1][j+1] + grid[i+1][j+2]) == 15
                        && (grid[i][j] + grid[i+1][j] + grid[i+2][j]) == 15
                        && (grid[i][j+1] + grid[i+1][j+1] + grid[i+2][j+1]) == 15
                        && (grid[i][j] + grid[i+2][j+2]) == 10
                        && (grid[i+2][j] + grid[i][j+2]) == 10
                ){
                    count++;
                }
            }
        }

        return count;
    }

    private boolean magicNum(int[][] grid, int len1, int len2) {
        boolean res = true;
        int[] nums = new int[16];
        for(int i=len1;i<len1+3;i++){
            for(int j=len2;j<len2+3;j++){
                nums[grid[i][j]]++;
            }
        }

        for(int x=1;x<=9;x++){
            if(nums[x] != 1){
                res = false;
                break;
            }
        }

        return res;
    }



    public int numMagicSquaresInside2(int[][] grid) {
        int R = grid.length, C = grid[0].length;
        int ans = 0;
        for (int r = 0; r < R-2; ++r)
            for (int c = 0; c < C-2; ++c) {
                if (grid[r+1][c+1] != 5) continue;  // optional skip
                if (magic(grid[r][c], grid[r][c+1], grid[r][c+2],
                        grid[r+1][c], grid[r+1][c+1], grid[r+1][c+2],
                        grid[r+2][c], grid[r+2][c+1], grid[r+2][c+2]))
                    ans++;
            }

        return ans;
    }

    public boolean magic(int... vals) {
        int[] count = new int[16];
        for (int v: vals) count[v]++;
        for (int v = 1; v <= 9; ++v)
            if (count[v] != 1)
                return false;

        return (vals[0] + vals[1] + vals[2] == 15 &&
                vals[3] + vals[4] + vals[5] == 15 &&
                vals[6] + vals[7] + vals[8] == 15 &&
                vals[0] + vals[3] + vals[6] == 15 &&
                vals[1] + vals[4] + vals[7] == 15 &&
                vals[2] + vals[5] + vals[8] == 15 &&
                vals[0] + vals[4] + vals[8] == 15 &&
                vals[2] + vals[4] + vals[6] == 15);
    }

}
